home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / p063b9s.zip / UNIT / ZMISC.PAS < prev    next >
Pascal/Delphi Source File  |  1996-06-25  |  19KB  |  756 lines

  1. UNIT ZMisc;
  2. {╔══════════════════════════════════════════════════════════════════════════╗}
  3. {║ Global ZModem routines                        Last changed: 25.06.96  SA ║}
  4. {║                                                                          ║}
  5. {║                         (C) Copyright 1989-96 by                         ║}
  6. {║       Dan Wulff, Jens Sandalgaard, Steen Christensen & S¢ren Ager        ║}
  7. {║                                                                          ║}
  8. {║ This source may not be given to anybody, without the written permission  ║}
  9. {║ from The Portal Team.                                                    ║}
  10. {╚══════════════════════════════════════════════════════════════════════════╝}
  11. {$I POPDEFS.INC}
  12.  
  13. INTERFACE
  14.  
  15. USES Use32, OpDate;
  16.  
  17. CONST
  18.   ZPAD           = 42;            { '*'; }
  19.   ZDLE           = 24;
  20.   ZDLEE          = (ZDLE XOR 64);
  21.   ZBIN           = 65;            { 'A'; }
  22.   ZHEX           = 66;            { 'B'; }
  23.   ZBIN32         = 67;            { 'C'; }
  24.  
  25.   {--------------------------------------------------------------------}
  26.   { Frame types                                                        }
  27.   {--------------------------------------------------------------------}
  28.   ZRQINIT        = 0;
  29.   ZRINIT         = 1;
  30.   ZSINIT         = 2;
  31.   ZACK           = 3;
  32.   ZFILE          = 4;
  33.   ZSKIP          = 5;
  34.   ZNAK           = 6;
  35.   ZABORT         = 7;
  36.   ZFIN           = 8;
  37.   ZRPOS          = 9;
  38.   ZDATA          = 10;
  39.   ZEOF           = 11;
  40.   ZFERR          = 12;
  41.   ZCRC           = 13;
  42.   ZCHALLENGE     = 14;
  43.   ZCOMPL         = 15;
  44.   ZCAN           = 16;
  45.   ZFREECNT       = 17;
  46.   ZCOMMAND       = 18;
  47.   ZSTDERR        = 19;
  48.  
  49.   {--------------------------------------------------------------------}
  50.   { ZDLE sequences                                                     }
  51.   {--------------------------------------------------------------------}
  52.   ZCRCE          = 104;           { 'h'; }
  53.   ZCRCG          = 105;           { 'i'; }
  54.   ZCRCQ          = 106;           { 'j'; }
  55.   ZCRCW          = 107;           { 'k'; }
  56.   ZRUB0          = 108;           { 'l'; }
  57.   ZRUB1          = 109;           { 'm'; }
  58.  
  59.   {--------------------------------------------------------------------}
  60.   { ZGetZDL return values                                              }
  61.   { -1 is general error, -2 is timeout                                 }
  62.   {--------------------------------------------------------------------}
  63.   GOTOR          = 256;
  64.   GOTCRCE        = 360;           { (ZCRCE or GOTOR) }
  65.   GOTCRCG        = 361;           { (ZCRCG or GOTOR) }
  66.   GOTCRCQ        = 362;           { (ZCRCQ or GOTOR) }
  67.   GOTCRCW        = 363;           { (ZCRCW or GOTOR) }
  68.   GOTCAN         = 272;           { (GOTOR or 24)    }
  69.  
  70.   {--------------------------------------------------------------------}
  71.   { Byte positions within header array                                 }
  72.   {--------------------------------------------------------------------}
  73.   ZF0            = 3;
  74.   ZF1            = 2;
  75.   ZF2            = 1;
  76.   ZF3            = 0;
  77.   ZP0            = 0;
  78.   ZP1            = 1;
  79.   ZP2            = 2;
  80.   ZP3            = 3;
  81.  
  82.   {--------------------------------------------------------------------}
  83.   { Bit Masks for ZRINIT flags byte ZF0                                }
  84.   {--------------------------------------------------------------------}
  85.   CANFDX         = 1;
  86.   CANOVIO        = 2;
  87.   CANBRK         = 4;
  88.   CANCRY         = 8;
  89.   CANLZW         = 16;
  90.   CANFC32        = 32;
  91.  
  92.  
  93.   {--------------------------------------------------------------------}
  94.   { PARAMETERS FOR ZFILE FRAME...                                      }
  95.   {--------------------------------------------------------------------}
  96.  
  97.   {--------------------------------------------------------------------}
  98.   { Conversion options on of these in ZF0                              }
  99.   {--------------------------------------------------------------------}
  100.   ZCBIN          = 1;
  101.   ZCNL           = 2;
  102.   ZCRESUM        = 3;
  103.  
  104.   {--------------------------------------------------------------------}
  105.   { Management options, one of these in ZF1                            }
  106.   {--------------------------------------------------------------------}
  107.   ZMNEW          = 1;
  108.   ZMCRC          = 2;
  109.   ZMAPND         = 3;
  110.   ZMCLOB         = 4;
  111.   ZMSPARS        = 5;
  112.   ZMDIFF         = 6;
  113.   ZMPROT         = 7;
  114.  
  115.   {--------------------------------------------------------------------}
  116.   { Transport options, one of these in ZF2                             }
  117.   {--------------------------------------------------------------------}
  118.   ZTLZW          = 1;
  119.   ZTCRYPT        = 2;
  120.   ZTRLE          = 3;
  121.  
  122.   {--------------------------------------------------------------------}
  123.   { Parameters for ZCOMMAND frame ZF0 (otherwise 0)                    }
  124.   {--------------------------------------------------------------------}
  125.   ZCACK1         = 1;
  126.  
  127.   {--------------------------------------------------------------------}
  128.   { Miscellaneous definitions                                          }
  129.   {--------------------------------------------------------------------}
  130.   ok             = 0;
  131.   Error          = - 1;
  132.   TimeOut        = - 2;
  133.   RCDO           = - 3;
  134.   FUBAR          = - 4;
  135.  
  136.   XON            = (Byte('Q') AND 31);
  137.   XOFF           = (Byte('S') AND 31);
  138.   CPMEOF         = (Byte('Z') AND 31);
  139.  
  140.   RXBINARY       = False;
  141.   RXASCII        = False;
  142.   LZCONV         = 0;
  143.   LZMANAG        = 0;
  144.   LZTRANS        = 0;
  145.   PATHLEN        = 128;
  146.   KSIZE          = 1024;
  147.   WAZOOMAX       : Word = 8192;
  148.  
  149.   {--------------------------------------------------------------------}
  150.   { Parameters for calling ZModem routines                             }
  151.   {--------------------------------------------------------------------}
  152.   SPEC_COND      = 2;
  153.   ZTRUE          = 1;
  154.   ZFALSE         = 0;
  155.   END_BATCH      = - 1;
  156.   NOTHING_TO_DO  = - 2;
  157.   DELETE_AFTER   = '-';
  158.   SHOW_DELETE_AFTER = '^';
  159.   TRUNC_AFTER    = '#';
  160.   NOTHING_AFTER  = '@';
  161.   DO_WAZOO       = ZTRUE;
  162.   DONT_WAZOO     = ZFALSE;
  163.  
  164. TYPE
  165.   HeaderType     = ARRAY[0..3] OF Byte;
  166.   BufAry         = ARRAY[0..32768] OF Byte;
  167.  
  168. VAR
  169.   TxHdr, RxHdr   : HeaderType;
  170.   RxTimeOut      : LongInt;
  171.   RxType, RxFrameInd : Integer;
  172.   RxPos, Crc32   : LongInt;
  173.  
  174. FUNCTION  ZGetByte(Tenths : Integer) : Integer;
  175. PROCEDURE ZPutString(CONST s: String);
  176. PROCEDURE ZPutLongIntoHeader(Position : LongInt; VAR TxHdr : HeaderType);
  177. PROCEDURE ZSendHexHeader(HdrType : Integer; CONST Hdr : HeaderType);
  178. PROCEDURE ZSendCan;
  179. FUNCTION  ZGetHeader(VAR Hdr : HeaderType) : Integer;
  180. PROCEDURE ZUnCorkTransmitter;
  181. FUNCTION  ZGetZDL : Integer;
  182. FUNCTION  ZTimedRead : Integer;
  183.  
  184.  
  185. IMPLEMENTATION
  186.  
  187. USES OpCrt, OpString, ApTimer,
  188.      Globals, Crc, Com, TransVid, Util, MTask, PoPTypes, LogFile;
  189.  
  190.   PROCEDURE ZPutHex(HdrType : Integer);
  191.   VAR
  192.     s              : String[2];
  193.   BEGIN
  194.     s:=StLoCase(Hexb(Byte(HdrType)));
  195.     ComPort^.WriteByte(Byte(s[1]), False);
  196.     ComPort^.WriteByte(Byte(s[2]), False);
  197.   END;
  198.  
  199.   PROCEDURE ZUnCorkTransmitter;
  200.   VAR
  201.     t : EventTimer;
  202.   BEGIN
  203.     IF (NOT ComPort^.OutEmpty) AND ComPort^.Carrier THEN
  204.     BEGIN
  205.       NewTimer(t, Secs2Tics(5 * RxTimeOut) DIV 100);
  206.       REPEAT
  207. {        GiveUpTime};
  208.       UNTIL (TimerExpired(t)) OR (ComPort^.OutEmpty) OR (NOT ComPort^.Carrier);
  209.     END;
  210.     ComPort^.SetXOn(Off);
  211.     ComPort^.SetXOn(On);
  212.   END;
  213.  
  214.   PROCEDURE ZSendCan;
  215.   VAR
  216.     i : Byte;
  217.   BEGIN
  218.     ComPort^.PurgeOut; ComPort^.PurgeIn;
  219.     FOR i:=1 TO 10 DO
  220.       ComPort^.WriteByte(Can, False);
  221.     FOR i:=1 TO 10 DO
  222.       ComPort^.WriteByte(Bs, i=10);
  223.   END;
  224.  
  225.   FUNCTION ZTimedRead : Integer;
  226.   VAR
  227.     c              : Integer;
  228.   BEGIN
  229. {$IFDEF ZDebug}
  230.     AddLog('!','ZTimedRead');
  231. {$ENDIF}
  232.     REPEAT
  233.       c:=ZGetByte(RxTimeOut);
  234.       IF c<0 THEN Break;
  235.       c:=c AND $7f;
  236.       CASE c OF
  237.         XON,
  238.         XOFF : Continue;
  239.         Cr,
  240.         Lf,
  241.         ZDLE : Break;
  242.         ELSE   IF (c AND $60)<>0 THEN Break ELSE Continue;
  243.       END;
  244.     UNTIL False;
  245. {$IFDEF ZDebug}
  246.     AddLog('!','END ZTimedRead');
  247. {$ENDIF}
  248.     ZTimedRead:=c;
  249.   END;
  250.  
  251. (*  FUNCTION ZTimedRead : Integer;
  252.   VAR
  253.     c              : Integer;
  254.   BEGIN
  255.     {$IFDEF ZDebug}
  256.     FastWrite('ZTimedRead              ',1,1,7);
  257.   {$ENDIF}
  258.     WHILE True DO
  259.     BEGIN
  260.       c:=ZGetByte(RxTimeOut);
  261.       IF c < 0 THEN
  262.       BEGIN
  263.         ZTimedRead:=c;
  264.         Exit;
  265.       END;
  266.       CASE (c AND $7f) OF
  267.         XON,
  268.         XOFF : {continue} ;
  269.         Cr,
  270.         Lf,
  271.         ZDLE : BEGIN
  272.                  ZTimedRead:=c;
  273.                  Exit;
  274.                END;
  275.       ELSE                        {IF (c and $60) <> 0 THEN}
  276.         BEGIN
  277.           ZTimedRead:=c;
  278.           Exit;
  279.         END;
  280.       END;
  281.     END;
  282.   END;
  283. *)
  284.  
  285.   PROCEDURE ZPutLongIntoHeader(Position : LongInt; VAR TxHdr : HeaderType);
  286.   BEGIN
  287.     LongInt(TxHdr):=Position;
  288.   END;
  289.  
  290.   FUNCTION ZPullLongFromHeader(CONST Hdr : HeaderType) : LongInt;
  291.   BEGIN
  292.     ZPullLongFromHeader:=LongInt(Hdr);
  293.   END;
  294.  
  295.   FUNCTION ZGetZDL : Integer;
  296.   VAR
  297.     c              : Integer;
  298.   BEGIN
  299.     c:=ZGetByte(RxTimeOut);
  300.     IF c<>ZDLE THEN
  301.     BEGIN
  302.       ZGetZDL:=c;
  303.     END ELSE
  304.     BEGIN
  305.       c:=ZGetByte(RxTimeOut);
  306.       CASE c OF
  307.         RCDO: ZGetZDL:=c; { DWK 16.12.92 }
  308.         Can : BEGIN
  309.                 c:=ZGetByte(RxTimeOut);
  310.                 IF c<0 THEN ZGetZDL:=c ELSE
  311.                   IF c=CAN THEN
  312.                   BEGIN
  313.                     c:=ZGetByte(RxTimeOut);
  314.                     IF c<0 THEN ZGetZDL:=c ELSE
  315.                     IF c=Can THEN
  316.                     BEGIN
  317.                       c:=ZGetByte(RxTimeOut);
  318.                       IF c<0 THEN ZGetZDL:=c ELSE ZGetZDL:=GOTCAN;
  319.                     END;
  320.                   END;
  321.               END;
  322.         ZCRCE,
  323.         ZCRCG,
  324.         ZCRCQ,
  325.         ZCRCW : ZGetZDL:=(c OR GOTOR);
  326.         ZRUB0 : ZGetZDL:=$7f;
  327.         ZRUB1 : ZGetZDL:=$ff;
  328.         ELSE    BEGIN
  329.                  IF c<0 THEN
  330.                    ZGetZDL:=c
  331.                  ELSE
  332.                    IF ((c AND $60)=$40) THEN
  333.                      ZGetZDL:=(c XOR $40)
  334.                    ELSE
  335.                      ZGetZDL:=Error;
  336.                 END;
  337.       END;
  338.     END;
  339.   END;
  340.  
  341.   FUNCTION ZGetHex: Integer;
  342.   VAR
  343.     c, n : Integer;
  344.   BEGIN
  345. {$IFDEF ZDebug}
  346.     AddLog('!','ZGetHex');
  347. {$ENDIF}
  348.     n:=ZTimedRead;
  349.     IF n<0 THEN
  350.     BEGIN
  351.       ZGetHex:=n;
  352.       Exit;
  353.     END;
  354.     Dec(n, 48);
  355.     IF n>9 THEN Dec(n,39);
  356.     IF (n AND $fff0)<>0 THEN
  357.     BEGIN
  358.       ZGetHex:=Error;
  359.       Exit;
  360.     END;
  361.  
  362.     c:=ZTimedRead;
  363.     IF c<0 THEN
  364.     BEGIN
  365.       ZGetHex:=c;
  366.       Exit;
  367.     END;
  368.     Dec(c, 48);
  369.     IF c>9 THEN Dec(c, 39);
  370.     IF (c AND $fff0)<>0 THEN
  371.     BEGIN
  372.       ZGetHex:=Error;
  373.       Exit;
  374.     END;
  375.     ZGetHex:=((n SHL 4)+c);
  376.   END;
  377.  
  378.   FUNCTION ZGetBinaryHeader(VAR Hdr: HeaderType): Integer;
  379.   VAR
  380.     c, n  : Integer;
  381.     Crc16 : Word;
  382.   BEGIN
  383. {$IFDEF ZDebug}
  384.     AddLog('!','ZGetBinaryHeader');
  385. {$ENDIF}
  386.     c:=ZGetZDL;
  387.     IF Hi(c)<>0 THEN
  388.     BEGIN
  389.       ZGetBinaryHeader:=c;
  390.       Exit;
  391.     END;
  392.     RxType:=c;
  393.     Crc16:=UpdCrc16(c, 0);
  394.     FOR n:=0 TO 3 DO
  395.     BEGIN
  396.       c:=ZGetZDL;
  397.       IF Hi(c)<>0 THEN
  398.       BEGIN
  399.         ZGetBinaryHeader:=c;
  400.         Exit;
  401.       END;
  402.       Crc16:=UpdCrc16(c, Crc16);
  403.       Hdr[n]:=c;
  404.     END;
  405.     c:=ZGetZDL;
  406.     IF Hi(c)<>0 THEN
  407.     BEGIN
  408.       ZGetBinaryHeader:=c;
  409.       Exit;
  410.     END;
  411.     Crc16:=UpdCrc16(c, Crc16);
  412.     c:=ZGetZDL;
  413.     IF Hi(c)<>0 THEN
  414.     BEGIN
  415.       ZGetBinaryHeader:=c;
  416.       Exit;
  417.     END;
  418.     Crc16:=UpdCrc16(c, Crc16);
  419.     IF Crc16<>0 THEN
  420.     BEGIN
  421.       ShowError('CRC error',True,false,false);
  422.       ZGetBinaryHeader:=Error;
  423.       Exit;
  424.     END;
  425.     ZGetBinaryHeader:=RxType;
  426.   END;
  427.  
  428.   FUNCTION Z32GetBinaryHeader(VAR Hdr: HeaderType): Integer;
  429.   VAR
  430.     n     : Byte;
  431.     c     : Integer;
  432.     Crc32 : LongInt;
  433.   BEGIN
  434. {$IFDEF ZDebug}
  435.     AddLog('!','Z32GetBinaryHeader');
  436. {$ENDIF}
  437.     c:=ZGetZDL;
  438.     IF Hi(c)<>0 THEN
  439.     BEGIN
  440.       Z32GetBinaryHeader:=c;
  441.       Exit;
  442.     END;
  443.     RxType:=c;
  444.     Crc32:=$ffffffff;
  445.     Crc32:=UpdCrc32(c, Crc32);
  446.     FOR n:=0 TO 3 DO
  447.     BEGIN
  448.       c:=ZGetZDL;
  449.       IF Hi(c)<>0 THEN
  450.       BEGIN
  451.         Z32GetBinaryHeader:=c;
  452.         Exit;
  453.       END;
  454.       Crc32:=UpdCrc32(c, Crc32);
  455.       Hdr[n]:=c;
  456.     END;
  457.     FOR n:=0 TO 3 DO
  458.     BEGIN
  459.       c:=ZGetZDL;
  460.       IF Hi(c)<>0 THEN
  461.       BEGIN
  462.         Z32GetBinaryHeader:=c;
  463.         Exit;
  464.       END;
  465.       Crc32:=UpdCrc32(c, Crc32);
  466.     END;
  467.     IF Crc32<>$debb20e3 THEN
  468.     BEGIN
  469.       ShowError('CRC error',True,false,false);
  470.       Z32GetBinaryHeader:=Error;
  471.       Exit;
  472.     END;
  473.     Z32GetBinaryHeader:=RxType;
  474.   END;
  475.  
  476.   FUNCTION ZGetHexHeader(VAR Hdr : HeaderType) : Integer;
  477.   VAR
  478.     c     : Integer;
  479.     Crc16 : Word;
  480.     n     : Byte;
  481.   BEGIN
  482. {$IFDEF ZDebug}
  483.     AddLog('!','ZGetHexHeader');
  484. {$ENDIF}
  485.     c:=ZGetHex;
  486.     IF Hi(c) <> 0 THEN
  487.     BEGIN
  488.       ZGetHexHeader:=c;
  489.       Exit;
  490.     END;
  491.     RxType:=c;
  492.     Crc16:=UpdCrc16(c, 0);
  493.     FOR n:=0 TO 3 DO
  494.     BEGIN
  495.       c:=ZGetHex;
  496.       IF Hi(c) <> 0 THEN
  497.       BEGIN
  498.         ZGetHexHeader:=c;
  499.         Exit;
  500.       END;
  501.       Crc16:=UpdCrc16(Lo(c), Crc16);
  502.       Hdr[n]:=Lo(c);
  503.     END;
  504.     c:=ZGetHex;
  505.     IF Hi(c)<>0 THEN
  506.     BEGIN
  507.       ZGetHexHeader:=c;
  508.       Exit;
  509.     END;
  510.     Crc16:=UpdCrc16(c, Crc16);
  511.     c:=ZGetHex;
  512.     IF Hi(c) <> 0 THEN
  513.     BEGIN
  514.       ZGetHexHeader:=c;
  515.       Exit;
  516.     END;
  517.     Crc16:=UpdCrc16(c, Crc16);
  518.     IF Crc16 <> 0 THEN
  519.     BEGIN
  520.       ShowError('CRC Error',True,false,false);
  521.       ZGetHexHeader:=Error;
  522.       Exit;
  523.     END;
  524.     IF ZGetByte(1)=Cr THEN ZGetByte(1);
  525.     ZGetHexHeader:=RxType;
  526.   END;
  527.  
  528.   FUNCTION ZGetHeader(VAR Hdr : HeaderType) : Integer;
  529.   LABEL
  530.     Again, Agn2, EndCase2, EndCase3, GOTCAN, Done, Splat;
  531.   VAR
  532.     n              : LongInt;
  533.     CanCount       : ShortInt;
  534.     c              : Integer;
  535.   BEGIN
  536. {$IFDEF ZDebug}
  537.     AddLog('!','ZGetHeader');
  538. {$ENDIF}
  539.     n:=ComPort^.GetBaudRate;
  540.     CanCount:=5;
  541. Again:
  542. {$IFDEF ZDebug}
  543.     AddLog('!','L11');
  544. {$ENDIF}
  545.     IF GotESC THEN
  546.     BEGIN
  547.       ZSendCan;
  548.       ZGetHeader:=ZCAN;
  549.       Exit;
  550.     END;
  551.  
  552.     RxFrameInd:=0; RxType:=0;
  553.     c:=ZTimedRead;
  554. {$IFDEF BoDebug}
  555.     if c=error then AddLog('!','L1');
  556. {$ENDIF}
  557.  
  558.     CASE c OF
  559.       ZPAD,
  560.       (ZPAD OR 128) : ;
  561.       RCDO,
  562.       TimeOut : GOTO Done;
  563.       Can : BEGIN
  564. GOTCAN:
  565. {$IFDEF ZDebug}
  566.               AddLog('!','L12');
  567. {$ENDIF}
  568.               Dec(CanCount);
  569.               IF CanCount <= 0 THEN
  570.               BEGIN
  571.                 c:=ZCAN;
  572.                 GOTO Done;
  573.               END;
  574.               c:=ZGetByte(1);
  575.               CASE c OF
  576.                 TimeOut : GOTO Again;
  577.                 ZCRCW : BEGIN
  578.                           c:=Error;
  579.                           GOTO Done;
  580.                         END;
  581.                 RCDO  : GOTO Done;
  582.                 Can   : BEGIN
  583.                           Dec(CanCount);
  584.                           IF CanCount <= 0 THEN
  585.                           BEGIN
  586.                             c:=ZCAN;
  587.                             GOTO Done;
  588.                           END;
  589.                           GOTO Again;
  590.                         END;
  591.               END;
  592.               GOTO Agn2; { DWK 01.03.1993 }
  593.             END;
  594.       ELSE BEGIN
  595. Agn2:
  596. {$IFDEF ZDebug}
  597.     AddLog('!','L10');
  598. {$ENDIF}
  599.         Dec(n);
  600.         IF n <= 0 THEN
  601.         BEGIN
  602.           ShowError('FUBAR',True,false,false);
  603.           ZGetHeader:=Error;
  604.           Exit;
  605.         END;
  606.         IF c <> Can THEN CanCount:=5;
  607.         GOTO Again;
  608.       END;
  609.     END;                          {Case}
  610. {$IFDEF ZDebug}
  611.     AddLog('!','L05');
  612. {$ENDIF}
  613.     CanCount:=5;
  614. Splat:
  615.  
  616. {$IFDEF ZDebug}
  617.     AddLog('!','L06');
  618. {$ENDIF}
  619.     c:=ZTimedRead;
  620. {$IFDEF BoDebug}
  621.     if c=error then AddLog('!','L2');
  622. {$ENDIF}
  623.     CASE c OF
  624.       ZDLE : {fallthrough} ;
  625.       ZPAD : GOTO Splat;
  626.       RCDO,
  627.       TimeOut : GOTO Done;
  628.       ELSE GOTO Agn2;
  629.     END;
  630. EndCase2:
  631. {$IFDEF ZDebug}
  632.     AddLog('!','L07');
  633. {$ENDIF}
  634.  
  635.     c:=ZTimedRead;
  636. {$IFDEF BoDebug}
  637.     if c=error then AddLog('!','L3');
  638. {$ENDIF}
  639.     CASE c OF
  640.       ZBIN : BEGIN
  641.                RxFrameInd:=ZBIN;
  642.                Crc32:=0;
  643.                c:=ZGetBinaryHeader(Hdr);
  644.              END;
  645.       ZBIN32 : BEGIN
  646.                  Crc32:=ZBIN32;
  647.                  RxFrameInd:=ZBIN32;
  648.                  c:=Z32GetBinaryHeader(Hdr);
  649.                END;
  650.       ZHEX : BEGIN
  651.                RxFrameInd:=ZHEX;
  652.                Crc32:=0;
  653.                c:=ZGetHexHeader(Hdr);
  654.              END;
  655.       Can : GOTO GOTCAN;
  656.       RCDO,
  657.       TimeOut : GOTO Done;
  658.       ELSE GOTO Agn2;
  659.     END;                          {case}
  660. EndCase3:
  661.  
  662. {$IFDEF ZDebug}
  663.     AddLog('!','L08');
  664. {$ENDIF}
  665.     RxPos:=ZPullLongFromHeader(Hdr);
  666. Done:
  667. {$IFDEF ZDebug}
  668.     AddLog('!','L09');
  669. {$ENDIF}
  670.     ZGetHeader:=c;
  671.   END;                            {ZGetHeader}
  672.  
  673.   PROCEDURE ZSendHexHeader(HdrType: Integer; CONST Hdr: HeaderType);
  674.   VAR
  675.     Crc16          : Word;
  676.     n              : Byte;
  677.   BEGIN
  678. {$IFDEF ZDebug}
  679.     AddLog('!','ZSendHexHeader');
  680. {$ENDIF}
  681.     ZUnCorkTransmitter;
  682.     ComPort^.WriteByte(ZPAD, False);
  683.     ComPort^.WriteByte(ZPAD, False);
  684.     ComPort^.WriteByte(ZDLE, False);
  685.     ComPort^.WriteByte(ZHEX, False);
  686.     ZPutHex(HdrType);
  687.     Crc16:=UpdCrc16(HdrType, 0);
  688.     FOR n:=0 TO 3 DO
  689.     BEGIN
  690.       ZPutHex(Hdr[n]);
  691.       Crc16:=UpdCrc16(Hdr[n], Crc16);
  692.     END;
  693.     Crc16:=UpdCrc16(0, Crc16);
  694.     Crc16:=UpdCrc16(0, Crc16);
  695.     ZPutHex(Hi(Crc16));
  696.     ZPutHex(Lo(Crc16));
  697.     IF (HdrType <> ZFIN) AND (HdrType <> ZACK) THEN ComPort^.WriteByte(17, False);
  698.     ComPort^.WriteByte(Cr, False);
  699.     ComPort^.WriteByte(Lf, True);
  700.     IF NOT ComPort^.Carrier THEN ComPort^.PurgeOut;
  701.   END;
  702.  
  703.   PROCEDURE ZPutString(CONST s: String);
  704.   VAR
  705.     a              : Byte;
  706.   BEGIN
  707.     FOR a:=1 TO Length(s) DO
  708.       CASE Byte(s[a]) OF
  709.         222 : Pause(200);
  710.         221 : {ZsendBreak} ;
  711.         ELSE ComPort^.WriteByte(Byte(s[a]), a=Length(s));
  712.       END;
  713.     ZUnCorkTransmitter;
  714.   END;
  715.  
  716.   FUNCTION ZGetByte(Tenths: Integer) : Integer;
  717.   VAR
  718.     TOut : EventTimer;
  719.   BEGIN
  720. {
  721.     IF NOT FCarrier THEN
  722.     BEGIN
  723.       ZGetByte:=RCDO;
  724.       Exit;
  725.     END;
  726. }
  727.     IF ComPort^.Keypressed THEN
  728.     BEGIN
  729.       ZGetByte:=Integer(ComPort^.ReadByte);
  730.     END ELSE
  731.     BEGIN
  732.       NewTimer(TOut, Secs2Tics(Tenths*10) DIV 100);
  733.       REPEAT
  734.         IF NOT ComPort^.Carrier THEN
  735.         BEGIN
  736.           ZGetByte:=RCDO;
  737.           Exit;
  738.         END;
  739.         IF ComPort^.Keypressed THEN
  740.         BEGIN
  741.           ZGetByte:=Integer(ComPort^.ReadByte);
  742.           Exit;
  743.         END;
  744.         IF GotESC THEN
  745.         BEGIN
  746.           ZGetByte:=Error;
  747.           Exit;
  748.         END;
  749.       UNTIL TimerExpired(TOut);
  750.       ZGetByte:=TimeOut;
  751.     END;
  752.   END;
  753.  
  754. END.
  755.  
  756.